/*
 * ccresult_access.c
 *
 *  Created on: 2012/05/30
 *      Author: guanxiaoying
 */
#include "../coredef.h"
#include "../cc/cc.h"

TYPE_DECLARATION DLL_EXPORT CDeclaration;
EXTERNAL_SYMBOL( CDeclaration );
static BOOL isTypename( AST astIndex ){
	return stDeclarationAccess.namespace.get( astIndex ) == xNAMESPACE_TYPENAME;
}
static BOOL isDMember( AST astIndex ){
	return stDeclarationAccess.namespace.get( astIndex ) == xNAMESPACE_MEM;
}
static BOOL isDParameter( AST astIndex ){
	return stDeclarationAccess.namespace.get( astIndex ) == xNAMESPACE_ARG;
}
static BOOL isOrdinaryDeclaration( AST astIndex ){
	return stDeclarationAccess.namespace.get( astIndex ) == xNAMESPACE_ORD;
}
VOID CDeclarationInit( VOID ){
//	AST  (*getMax)( VOID );
	CDeclaration.getMax = stDeclarationAccess.getMax;
//	AST  (*getTypeSpecifier)( AST astIndex );
	CDeclaration.getTypeSpecifier = stDeclarationAccess.typeSpecifier.get;
//	AST  (*getDeclarator)(AST astIndex);
	CDeclaration.getDeclarator = stDeclarationAccess.declarator.get;
//	AST  (*getCodeScope)( AST astIndex );
	CDeclaration.getCodeScope = stDeclarationAccess.codeScp.get;
//	BOOL  (*isTypename)( AST astIndex );
	CDeclaration.isTypename = isTypename;
//	BOOL  (*isMember)( AST astIndex );
	CDeclaration.isMember = isDMember;
//	BOOL  (*isParameter)( AST astIndex );
	CDeclaration.isParameter = isDParameter;
//	BOOL  (*isOrdinaryDeclaration)( AST astIndex );
	CDeclaration.isOrdinaryDeclaration = isOrdinaryDeclaration;
//	AST  (*getNextDeclaration)( AST astIndex );
	CDeclaration.getNextDeclaration = stDeclarationAccess.next.get;
}
TYPE_TYPESPECIFIER DLL_EXPORT CTypeSpecifier;
EXTERNAL_SYMBOL( CTypeSpecifier );
static BOOL isBasicType( AST astIndex ){
	return TYPEDEF_BASE == stTypeSpecifierAccess.specifyKind.get( astIndex );
}
static BOOL isUnion( AST astIndex ){
	return TYPEDEF_UNION == stTypeSpecifierAccess.specifyKind.get( astIndex );
}
static BOOL isStruct( AST astIndex ){
	return TYPEDEF_STRUCT == stTypeSpecifierAccess.specifyKind.get( astIndex );
}
static BOOL isEnum( AST astIndex ){
	return TYPEDEF_ENUM == stTypeSpecifierAccess.specifyKind.get( astIndex );
}
static BOOL isTypedefIdentifier( AST astIndex ){
	return TYPEDEF_TYPEDEF == stTypeSpecifierAccess.specifyKind.get( astIndex );
}

VOID CTypeSpecifierInit( VOID ){
//	AST  (*getMax)( VOID );
	CTypeSpecifier.getMax = stTypeSpecifierAccess.getMax;
//	AST  (*getCodeScope)( AST astIndex );
	CTypeSpecifier.getCodeScope = stTypeSpecifierAccess.codeScp.get;
//	AST  (*getDeclaration)(AST astIndex);
	CTypeSpecifier.getDeclaration = stTypeSpecifierAccess.declaration.get;
//	U2   (*getRestrictNum)(AST astIndex );
	CTypeSpecifier.getRestrictNum = stTypeSpecifierAccess.restrictNum.get;
//	U2   (*getVolatileNum)(AST astIndex );
	CTypeSpecifier.getVolatileNum = stTypeSpecifierAccess.volatileNum.get;
//	U2   (*getConstNum)(AST astIndex );
	CTypeSpecifier.getConstNum = stTypeSpecifierAccess.constNum.get;
//	U2   (*getExternNum)(AST astIndex );
	CTypeSpecifier.getExternNum = stTypeSpecifierAccess.externNum.get;
//	U2   (*getStaticNum)(AST astIndex );
	CTypeSpecifier.getStaticNum = stTypeSpecifierAccess.staticNum.get;
//	U2   (*getAutoNum)(AST astIndex );
	CTypeSpecifier.getAutoNum = stTypeSpecifierAccess.autoNum.get;
//	U2   (*getTypedefNum)(AST astIndex );
	CTypeSpecifier.getTypedefNum = stTypeSpecifierAccess.typedefNum.get;
//	U2   (*getRegisterNum)(AST astIndex );
	CTypeSpecifier.getRegisterNum = stTypeSpecifierAccess.registerNum.get;
//	U2   (*getInterruptNum)(AST astIndex );
	CTypeSpecifier.getInterruptNum = stTypeSpecifierAccess.interruptNum.get;
//	U2   (*getInlineNum)(AST astIndex );
	CTypeSpecifier.getInlineNum = stTypeSpecifierAccess.inlineNum.get;
//	U2   (*getAsmNum)(AST astIndex );
	CTypeSpecifier.getAsmNum = stTypeSpecifierAccess.asmNum.get;
//	U2   (*getNearNum)(AST astIndex );
	CTypeSpecifier.getNearNum = stTypeSpecifierAccess.nearNum.get;
//	U2   (*getFarNum)(AST astIndex );
	CTypeSpecifier.getFarNum = stTypeSpecifierAccess.farNum.get;
//	BOOL   (*isBasicType)(AST astIndex );
	CTypeSpecifier.isBasicType = isBasicType;
//	BOOL   (*isUnion)(AST astIndex );
	CTypeSpecifier.isUnion = isUnion;
//	BOOL   (*isStruct)(AST astIndex );
	CTypeSpecifier.isStruct = isStruct;
//	BOOL   (*isEnum)(AST astIndex );
	CTypeSpecifier.isEnum = isEnum;
//	BOOL   (*isTypedefIdentifier)(AST astIndex );
	CTypeSpecifier.isTypedefIdentifier = isTypedefIdentifier;
//	AST   (*getMemDeclarationList)(AST astIndex );
	CTypeSpecifier.getMemDeclarationList = stTypeSpecifierAccess.memberChain.get;
//	AST   (*getTagOrTypedefIdentifier)(AST astIndex );
	CTypeSpecifier.getTagOrTypedefIdentifier = stTypeSpecifierAccess.symbol.get;
//	AST   (*getTypeInfo)(AST astIndex );
	CTypeSpecifier.getTypeInfo = stTypeSpecifierAccess.typeinfo.get;
}
TYPE_DECLARATOR DLL_EXPORT CDeclarator;
EXTERNAL_SYMBOL( CDeclarator );
static BOOL isPointerDeclarator ( AST astIndex ){
	return DECLARATOR_POINTER == stDeclaratorAccess.declaratorKind.get( astIndex );
}
static BOOL isParentheseDeclarator ( AST astIndex ){
	return DECLARATOR_PAREN == stDeclaratorAccess.declaratorKind.get( astIndex );
}
static BOOL isArrayDeclarator ( AST astIndex ){
	return DECLARATOR_ARRAY == stDeclaratorAccess.declaratorKind.get( astIndex );
}
static BOOL isFunctionDeclarator ( AST astIndex ){
	return DECLARATOR_FUNC == stDeclaratorAccess.declaratorKind.get( astIndex );
}
static BOOL isSymbolDeclarator ( AST astIndex ){
	return DECLARATOR_SYM == stDeclaratorAccess.declaratorKind.get( astIndex );
}
static BOOL isBitfieldDeclarator ( AST astIndex ){
	return DECLARATOR_BITFIELD == stDeclaratorAccess.declaratorKind.get( astIndex );
}
static BOOL isInitialExpDeclarator ( AST astIndex ){
	return DECLARATOR_INIT == stDeclaratorAccess.declaratorKind.get( astIndex );
}
VOID CDeclaratorInit( VOID ){
//	AST  (*getMax)( VOID );
	CDeclarator.getMax = stDeclaratorAccess.getMax;
//	AST  (*getNextDeclarator)(AST astIndex);
	CDeclarator.getNextDeclarator = stDeclaratorAccess.nextDeclarator.get;
//	AST  (*getParentDeclarator)(AST astIndex);
	CDeclarator.getParentDeclarator = stDeclaratorAccess.parentDeclarator.get;
//	AST  (*getDeclaration)(AST astIndex);
	CDeclarator.getDeclaration = stDeclaratorAccess.declaration.get;
//	BOOL  (*isPointerDeclarator)(AST astIndex);
	CDeclarator.isPointerDeclarator = isPointerDeclarator;
//	BOOL  (*isParentheseDeclarator)(AST astIndex);
	CDeclarator.isParentheseDeclarator = isParentheseDeclarator;
//	BOOL  (*isArrayDeclarator)(AST astIndex);
	CDeclarator.isArrayDeclarator = isArrayDeclarator;
//	BOOL  (*isFunctionDeclarator)(AST astIndex);
	CDeclarator.isFunctionDeclarator = isFunctionDeclarator;
//	BOOL  (*isSymbolDeclarator)(AST astIndex);
	CDeclarator.isSymbolDeclarator = isSymbolDeclarator;
//	BOOL  (*isBitfieldDeclarator)(AST astIndex);
	CDeclarator.isBitfieldDeclarator = isBitfieldDeclarator;
//	BOOL  (*isInitialExpDeclarator)(AST astIndex);
	CDeclarator.isInitialExpDeclarator = isInitialExpDeclarator;
//	AST   (*bitfield_getConstExp)(AST astIndex);
	CDeclarator.bitfield_getConstExp = stDeclaratorAccess.bitIdx.get;
//	AST   (*array_getArrayIndex)(AST astIndex);
	CDeclarator.array_getArrayIndex = stDeclaratorAccess.arrayIdx.get;
//	AST   (*function_getParamChain)(AST astIndex);
	CDeclarator.function_getParamChain = stDeclaratorAccess.paramChain.get;
//	AST   (*initExp_getInitExp)(AST astIndex);
	CDeclarator.initExp_getInitExp = stDeclaratorAccess.initialExpList.get;
//	AST   (*symbol_getSymbol)(AST astIndex);
	CDeclarator.symbol_getSymbol = stDeclaratorAccess.symbol.get;
//	U2    (*pointer_getVolatileNum)(AST astIndex );
	CDeclarator.pointer_getVolatileNum = stDeclaratorAccess.volatileNum.get;
//	U2    (*pointer_getConstNum)(AST astIndex );
	CDeclarator.pointer_getConstNum = stDeclaratorAccess.constNum.get;
//	U2    (*pointer_getRestrictNum)(AST astIndex );
	CDeclarator.pointer_getRestrictNum = stDeclaratorAccess.restrictNum.get;
//	AST   (*getChildDeclarator)(AST astIndex);
	CDeclarator.getChildDeclarator = stDeclaratorAccess.childDeclarator.get;
//	AST  (*getCodeScope)( AST astIndex );

	CDeclarator.getCodeScope = stDeclaratorAccess.codeScp.get;
	CDeclarator.getType = stDeclaratorAccess.type.get;
}
TYPE_STATEMENTINFO DLL_EXPORT CStatement;
EXTERNAL_SYMBOL( CStatement );
static BOOL isSTBlock( AST astIndex ){
	return STMT_BLOCK == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTExpression( AST astIndex ){
	return STMT_EXP == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTIf( AST astIndex ){
	return STMT_IF == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTFor( AST astIndex ){
	return STMT_FOR == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTWhile( AST astIndex ){
	return STMT_WHILE == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTDo( AST astIndex ){
	return STMT_DO == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTSwitch( AST astIndex ){
	return STMT_SWITCH == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTLabel( AST astIndex ){
	return STMT_LABEL == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTCase( AST astIndex ){
	return STMT_CASE == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTDefault( AST astIndex ){
	return STMT_DEFAULT == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTGoto( AST astIndex ){
	return STMT_GOTO == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTBreak( AST astIndex ){
	return STMT_BREAK == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTContinue( AST astIndex ){
	return STMT_CONTINUE == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTReturn( AST astIndex ){
	return STMT_RETURN == stStatementAccess.statmentKind.get( astIndex );
}
static BOOL isSTDecl( AST astIndex ){
	return STMT_DEC == stStatementAccess.statmentKind.get( astIndex );
}
//BOOL  (*isParentExp)( AST astIndex );
static BOOL isSTParentExp( AST astIndex ){
	return KIND_EXPRESSIONINFO == stStatementAccess.parentKind.get( astIndex );
}
//BOOL  (*isParentStmt)( AST astIndex );
static BOOL isSTParentStmt( AST astIndex ){
	return KIND_STATEMENTINFO == stStatementAccess.parentKind.get( astIndex );
}
//BOOL  (*isParentSymbol)( AST astIndex );
static BOOL isSTParentSymbol( AST astIndex ){
	return KIND_SYMDEFINFO == stStatementAccess.parentKind.get( astIndex );
}
VOID CStatementInit(VOID){
//	AST  (*getMax)( VOID );
	CStatement.getMax = stStatementAccess.getMax;
//	BOOL  (*isBlock)(AST astIndex);
	CStatement.isBlock = isSTBlock;
//	BOOL  (*isExpression)(AST astIndex);
	CStatement.isExpression = isSTExpression;
//	BOOL  (*isIf)(AST astIndex);
	CStatement.isIf = isSTIf;
//	BOOL  (*isFor)(AST astIndex);
	CStatement.isFor = isSTFor;
//	BOOL  (*isWhile)(AST astIndex);
	CStatement.isWhile = isSTWhile;
//	BOOL  (*isDo)(AST astIndex);
	CStatement.isDo = isSTDo;
//	BOOL  (*isSwitch)(AST astIndex);
	CStatement.isSwitch = isSTSwitch;
//	BOOL  (*isLabel)(AST astIndex);
	CStatement.isLabel = isSTLabel;
//	BOOL  (*isCase)(AST astIndex);
	CStatement.isCase = isSTCase;
//	BOOL  (*isDefault)(AST astIndex);
	CStatement.isDefault = isSTDefault;
//	BOOL  (*isGoto)(AST astIndex);
	CStatement.isGoto = isSTGoto;
//	BOOL  (*isBreak)(AST astIndex);
	CStatement.isBreak = isSTBreak;
//	BOOL  (*isContinue)(AST astIndex);
	CStatement.isContinue = isSTContinue;
//	BOOL  (*isReturn)(AST astIndex);
	CStatement.isReturn = isSTReturn;
	CStatement.isDecl = isSTDecl;
//	AST   (*for_getInit_Decl)( AST astIndex );
	CStatement.for_getInit_Decl = stStatementAccess.for_Init_Decl.get;
//	AST   (*for_getInitExp)( AST astIndex );
	CStatement.for_getInitExp = stStatementAccess.for_initExp.get;
//	AST   (*for_getCondExp)( AST astIndex );
	CStatement.for_getCondExp = stStatementAccess.for_CondExp.get;
//	AST   (*for_getIncExp)( AST astIndex );
	CStatement.for_getIncExp = stStatementAccess.for_IncExp.get;
//	AST   (*for_getBody)( AST astIndex );
	CStatement.for_getBody = stStatementAccess.for_Body.get;
//	AST   (*label_getLabelInfo)( AST astIndex );
	CStatement.label_getLabelInfo = stStatementAccess.label_name.get;
//	AST   (*label_getStatement)( AST astIndex );
	CStatement.label_getStatement = stStatementAccess.label_statement.get;
//	AST   (*label_getGotoChain)( AST astIndex );
	CStatement.label_getGotoChain = stStatementAccess.label_gotoChain.get;
//	AST   (*case_getConstExp)( AST astIndex );
	CStatement.case_getConstExp = stStatementAccess.case_constExp.get;
//	AST   (*case_getNextCase)( AST astIndex );
	CStatement.case_getNextCase = stStatementAccess.case_nextCase.get;
//	AST   (*case_getStatement)( AST astIndex );
	CStatement.case_getStatement = stStatementAccess.case_statement.get;
//	AST   (*case_getSwitch)( AST astIndex );
	CStatement.case_getSwitch = stStatementAccess.case_switch.get;
//	AST   (*default_getStatement)( AST astIndex );
	CStatement.default_getStatement = stStatementAccess.default_statement.get;
//	AST   (*default_getSwitch)( AST astIndex );
	CStatement.default_getSwitch = stStatementAccess.default_switch.get;
//	AST   (*block_getFirstStatement)( AST astIndex );
	CStatement.block_getChain = stStatementAccess.block_stmtlist.get;
//	AST   (*expStatement_getExp)( AST astIndex );
	CStatement.expStatement_getExp = stStatementAccess.exp_exp.get;
//	AST   (*if_getCondExp)( AST astIndex );
	CStatement.if_getCondExp = stStatementAccess.if_condExp.get;
//	AST   (*if_getBody)( AST astIndex );
	CStatement.if_getBody = stStatementAccess.if_body.get;
//	AST   (*if_getElseBody)( AST astIndex );
	CStatement.if_getElseBody = stStatementAccess.if_else_body.get;
//	AST   (*switch_getCondExp)( AST astIndex );
	CStatement.switch_getCondExp = stStatementAccess.switch_condExp.get;
//	AST   (*switch_getBody)( AST astIndex );
	CStatement.switch_getBody = stStatementAccess.switch_body.get;
//	AST   (*switch_getFirstCase)( AST astIndex );
	CStatement.switch_getFirstCase = stStatementAccess.switch_firstCase.get;
//	AST   (*switch_getDefault)( AST astIndex );
	CStatement.switch_getDefault = stStatementAccess.switch_default.get;
//	AST   (*while_getCondExp)( AST astIndex );
	CStatement.while_getCondExp = stStatementAccess.while_condExp.get;
//	AST   (*while_getBody)( AST astIndex );
	CStatement.while_getBody = stStatementAccess.while_body.get;
//	AST   (*do_getBody)( AST astIndex );
	CStatement.do_getBody = stStatementAccess.do_body.get;
//	AST   (*do_getCondExp)( AST astIndex );
	CStatement.do_getCondExp = stStatementAccess.do_condExp.get;
//	AST   (*goto_getLabelInfo)( AST astIndex );
	CStatement.goto_getLabelInfo = stStatementAccess.goto_sym.get;
//	AST   (*goto_getLabelStatement)( AST astIndex );
	CStatement.goto_getLabelStatement = stStatementAccess.goto_statement.get;
//	AST   (*continue_getLoop)( AST astIndex );
	CStatement.continue_getLoop = stStatementAccess.continue_statement.get;
//	AST   (*break_getLoopOrSwitch)( AST astIndex );
	CStatement.break_getLoopOrSwitch = stStatementAccess.break_statement.get;
//	AST   (*return_getExp)( AST astIndex );
	CStatement.return_getExp = stStatementAccess.return_exp.get;
//	AST   (*getCodeScope)( AST astIndex );
	CStatement.getCodeScope = stStatementAccess.codeScp.get;

	/*debug,12/11/14,S*/
	CStatement.dec_getDeclaration = stStatementAccess.dec_declaration.get;
	/*debug,12/11/14,E*/

	CStatement.isParentExp = isSTParentExp;
	CStatement.isParentStmt = isSTParentStmt;
	CStatement.isParentSymbol = isSTParentSymbol;
	CStatement.parent_GetExp = stStatementAccess.parent_expression.get;
	CStatement.parent_GetStmt = stStatementAccess.parent_statement.get;
	CStatement.parent_GetSymbol = stStatementAccess.parent_Symbol.get;
	CStatement.getBeforeStmt = stStatementAccess.before.get;
	CStatement.getNextStmt = stStatementAccess.next.get;
}
TYPE_EXPRESSIONINFO DLL_EXPORT CExpression;
EXTERNAL_SYMBOL( CExpression );
static BOOL isEConstantExp( AST astIndex ){
	return ( stExpressionAccess.constValue.get( astIndex ) != 0
			   || stExpressionAccess.result_value.get( astIndex ) != 0 )
			&& ( stExpressionAccess.constFlg.get( astIndex ) == CONSTANT_VALUE );
}
static BOOL isEAddressConstantExp( AST astIndex ){
	return stExpressionAccess.constFlg.get( astIndex ) == INIT_CONSTANT;
}
static BOOL isEParentExp( AST astIndex ){
	return KIND_EXPRESSIONINFO == stExpressionAccess.parentKind.get( astIndex );
}
static BOOL isEParentStatement( AST astIndex ){
	return KIND_STATEMENTINFO == stExpressionAccess.parentKind.get( astIndex );
}
static BOOL isEParentExpList( AST astIndex ){
	return KIND_INITIALEXPLIST == stExpressionAccess.parentKind.get( astIndex );
}
static BOOL isEParentDeclarator( AST astIndex ){
	return KIND_DECLARATOR == stExpressionAccess.parentKind.get( astIndex );
}
static BOOL isEParentDesignation( AST astIndex ){
	return KIND_INITDESIGNATION == stExpressionAccess.parentKind.get( astIndex );
}
VOID CExpressionInit( VOID ){
//	AST  (*getMax)( VOID );
	CExpression.getMax = stExpressionAccess.getMax;
//	U4   (*getOpKind)(AST astIndex);
	CExpression.getOpKind = stExpressionAccess.opKind.get;
//	AST   (*getPrimaryConstValue)(AST astIndex);
	CExpression.getPrimaryConstValue = stExpressionAccess.result_value.get;
//	AST   (*getPrimaryConstString)(AST astIndex);
	CExpression.getPrimaryConstString = stExpressionAccess.result_constStr.get;
//	AST   (*getPrimaryDeclaration)(AST astIndex);
	CExpression.getPrimaryDeclaration = stExpressionAccess.result_declaration.get;
//	AST   (*getPrimarySymbol)(AST astIndex);
	CExpression.getPrimarySymbol = stExpressionAccess.result_symbol.get;
//	AST   (*getPrimaryStatement)(AST astIndex);
	CExpression.getPrimaryStatement = stExpressionAccess.result_statement.get;
//	AST   (*getPrimaryInitializer)(AST astIndex);
	CExpression.getPrimaryInitializer = stExpressionAccess.result_exprlist.get;
//	AST   (*getTypeInfo)(AST astIndex);
	CExpression.getTypeInfo = stExpressionAccess.type.get;
//	AST   (*getCastedTypeInfo)(AST astIndex);
	CExpression.getCastedTypeInfo = stExpressionAccess.castedType.get;
//	AST   (*getCalcuteValue)(AST astIndex);
	CExpression.getCalcuteValue = stExpressionAccess.constValue.get;
//	AST   (*getCodeScope)(AST astIndex);
	CExpression.getCodeScope = stExpressionAccess.codeScp.get;
//	BOOL   (*isIllegalExp)(AST astIndex);
	CExpression.isIllegalExp = stExpressionAccess.bIllegal.get;
//	BOOL   (*isLValue)(AST astIndex);
	CExpression.isLValue = stExpressionAccess.blValue.get;
//	BOOL   (*isModifiable)(AST astIndex);
	CExpression.isModifiable = stExpressionAccess.bModifiabe.get;
//	BOOL   (*isConstantExp)(AST astIndex);
	CExpression.isConstantExp = isEConstantExp ;
//	BOOL   (*isAddressConstantExp)(AST astIndex);
	CExpression.isAddressConstantExp =  isEAddressConstantExp;
//	BOOL   (*isParentExp)(AST astIndex);
	CExpression.isParentExp =  isEParentExp;
//	BOOL   (*isParentStatement)(AST astIndex);
	CExpression.isParentStatement =  isEParentStatement;
//	BOOL   (*isParentExpList)(AST astIndex);
	CExpression.isParentExpList = isEParentExpList;
//	BOOL   (*isParentDeclarator)(AST astIndex);
	CExpression.isParentDeclarator = isEParentDeclarator;
//	BOOL   (*isParentDesignation)(AST astIndex);
	CExpression.isParentDesignation = isEParentDesignation;
//	AST   (*parent_getExp)(AST astIndex);
	CExpression.parent_getExp = stExpressionAccess.parent_expression.get;
//	AST   (*parent_getStatement)(AST astIndex);
	CExpression.parent_getStatement = stExpressionAccess.parent_statement.get;
//	AST   (*parent_getExpList)(AST astIndex);
	CExpression.parent_getExpList = stExpressionAccess.parent_explist.get;
//	AST   (*parent_getDeclarator)(AST astIndex);
	CExpression.parent_getDeclarator = stExpressionAccess.parent_declarator.get;
//	AST   (*parent_getDesignation)(AST astIndex);
	CExpression.parent_getDesignation = stExpressionAccess.parent_designation.get;
//	AST   (*getLeftNode)(AST astIndex);
	CExpression.getLeftNode = stExpressionAccess.leftChild.get;
//	AST   (*getRightNode)(AST astIndex);
	CExpression.getRightNode = stExpressionAccess.rightChild.get;
}
TYPE_EXPRESSIONKIND DLL_EXPORT CExpressionOpKind;
EXTERNAL_SYMBOL( CExpressionOpKind );
//	BOOL   (*isConstantNumber)( U4 operatorKind );
static BOOL   isConstantNumber( U4 operatorKind ){
	return EXPR_CONSTANT == operatorKind;
}
//	BOOL   (*isIdentifier)( U4 operatorKind );
static BOOL   isIdentifier( U4 operatorKind ){
	return EXPR_IDENTIFIER == operatorKind;
}
//	BOOL   (*isConstString)( U4 operatorKind );
static BOOL   isConstString( U4 operatorKind ){
	return EXPR_STRING == operatorKind;
}
//	BOOL   (*isParentheseExp)( U4 operatorKind );
static BOOL   isParentheseExp( U4 operatorKind ){
	return EXPR_PARENTHESE == operatorKind;
}
//	BOOL   (*isDeclaration)( U4 operatorKind );
static BOOL   isDeclaration( U4 operatorKind ){
	return EXPR_DECLARATION == operatorKind;
}
//	BOOL   (*isStatement)( U4 operatorKind );
static BOOL   isStatement( U4 operatorKind ){
	return EXPR_STATEMENT == operatorKind;
}
//	BOOL   (*isInitializer)( U4 operatorKind );
static BOOL   isInitializer( U4 operatorKind ){
	return EXPR_INITEXPRLIST == operatorKind;
}
//	BOOL   (*isPostfixOp)( U4 operatorKind );
static BOOL   isPostfixOp( U4 operatorKind ){
	return EXPR_ARRAY == operatorKind
			|| EXPR_FUNCTIONCALL == operatorKind
			|| EXPR_MEMBER == operatorKind
			|| EXPR_PTRMEMBER == operatorKind
			|| EXPR_POSTINC == operatorKind
			|| EXPR_POSTDEC == operatorKind
			|| EXPR_COMPOUNDLITERALS == operatorKind;
}
//	BOOL   (*isUnaryOp)( U4 operatorKind );
static BOOL   isUnaryOp( U4 operatorKind ){
	return EXPR_PREINC == operatorKind
			|| EXPR_PREDEC == operatorKind
			|| EXPR_ADDRESS == operatorKind
			|| EXPR_ASTERISK == operatorKind
			|| EXPR_PLUS == operatorKind
			|| EXPR_MINUS == operatorKind
			|| EXPR_NEGATION == operatorKind
			|| EXPR_BIT_NEGATION == operatorKind
			|| EXPR_SIZEOF == operatorKind;
}

//	BOOL   (*isCastOp)( U4 operatorKind );
static BOOL   isCastOp( U4 operatorKind ){
	return EXPR_CAST == operatorKind;
}
//	BOOL   (*isMultiplicativeOp)( U4 operatorKind );
static BOOL   isMultiplicativeOp( U4 operatorKind ){
	return EXPR_MUL == operatorKind
			|| EXPR_DIV == operatorKind
			|| EXPR_MOD == operatorKind;
}
//	BOOL   (*isAdditiveOp)( U4 operatorKind );
static BOOL   isAdditiveOp( U4 operatorKind ){
	return EXPR_ADD == operatorKind
			|| EXPR_SUB == operatorKind;
}
//	BOOL   (*isShiftOp)( U4 operatorKind );
static BOOL   isShiftOp( U4 operatorKind ){
	return EXPR_LEFTSHIFT == operatorKind
			|| EXPR_RIGHTSHIFT == operatorKind;
}
//	BOOL   (* isRelationalOp)( U4 operatorKind );
static BOOL   isRelationalOp( U4 operatorKind ){
	return EXPR_GREATER == operatorKind
			|| EXPR_GREATEREQU == operatorKind
			|| EXPR_LESS == operatorKind
			|| EXPR_LESSEQU == operatorKind;
}
//	BOOL   (*isEqualityOp)( U4 operatorKind );
static BOOL   isEqualityOp( U4 operatorKind ){
	return EXPR_EQUAL == operatorKind
			|| EXPR_UNEQUAL == operatorKind;
}
//	BOOL   (*isBitwiseAndOp)( U4 operatorKind );
static BOOL   isBitwiseAndOp( U4 operatorKind ){
	return EXPR_BIT_AND == operatorKind;
}
//	BOOL   (*isBitwiseExclusiveOrOp)( U4 operatorKind );
static BOOL   isBitwiseExclusiveOrOp( U4 operatorKind ){
	return EXPR_BIT_EXOR == operatorKind;
}
//	BOOL   (*isBitwiseInclusiveOrOp)( U4 operatorKind );
static BOOL   isBitwiseInclusiveOrOp( U4 operatorKind ){
	return EXPR_BIT_INOR == operatorKind;
}
//	BOOL   (*isLogicalAndOp)( U4 operatorKind );
static BOOL   isLogicalAndOp( U4 operatorKind ){
	return EXPR_LOGIC_AND == operatorKind;
}
//	BOOL  (*isLogicalOrOp)( U4 operatorKind );
static BOOL   isLogicalOrOp( U4 operatorKind ){
	return EXPR_LOGIC_OR == operatorKind;
}
//	BOOL   (*isConditionalOp)( U4 operatorKind );
static BOOL   isConditionalOp( U4 operatorKind ){
	return EXPR_CONDITION == operatorKind || EXPR_COLON == operatorKind;
}
//	BOOL   (*isAssignmentOp)( U4 operatorKind );
static BOOL   isAssignmentOp( U4 operatorKind ){
	return EXPR_ASSIGN == operatorKind
			|| EXPR_MUL_ASSIGN == operatorKind
			|| EXPR_DIV_ASSIGN == operatorKind
			|| EXPR_MOD_ASSIGN == operatorKind
			|| EXPR_ADD_ASSIGN == operatorKind
			|| EXPR_SUB_ASSIGN == operatorKind
			|| EXPR_LSHT_ASSIGN == operatorKind
			|| EXPR_RSHT_ASSIGN == operatorKind
			|| EXPR_BITAND_ASSIGN == operatorKind
			|| EXPR_BITEXOR_ASSIGN == operatorKind
			|| EXPR_BITINOR_ASSIGN == operatorKind;
}
//	BOOL   (*isCommaOp)( U4 operatorKind );
static BOOL   isCommaOp( U4 operatorKind ){
	return EXPR_COMMA == operatorKind;
}
static BOOL   isArgumentDelimiter( U4 operatorKind ){
	return EXPR_ARG == operatorKind;
}
//	PSZ  (*CcGetOpLabel)( U4 operatorKind );
static PSZ  CcGetOpLabel( U4 operatorKind ){
	switch( operatorKind ){
		case EXPR_IDENTIFIER   :
			return "@identifier";
		case EXPR_CONSTANT     :
			return "@constant";
		case EXPR_STRING       :
			return "@string";
		case EXPR_DECLARATION   :
			return "@declaration";
		case EXPR_STATEMENT     :
			return "@statement";
		case EXPR_INITEXPRLIST  :
			return "@initializer";
		case EXPR_PARENTHESE    :
			return "(@expression)";
		case EXPR_ARRAY         :
			return "@expression[@expression]";
		case EXPR_FUNCTIONCALL  :
			return "@expression[@expression]";
		case EXPR_MEMBER        :
			return "@expression.@identifier";
		case EXPR_PTRMEMBER     :
			return "@expression->@identifier";
		case EXPR_POSTINC       :
			return "@expression++";
		case EXPR_POSTDEC       :
			return "@expression--";
		case EXPR_COMPOUNDLITERALS  :
			return "(@declaration)@initializer";
		case EXPR_PREINC       :
			return "++@expression";
		case EXPR_PREDEC       :
			return "--@expression";
		case EXPR_ADDRESS    :
			return "&@expression";
		case EXPR_ASTERISK   :
			return "*@expression";
		case EXPR_PLUS       :
			return "+@expression";
		case EXPR_MINUS      :
			return "-@expression";
		case EXPR_NEGATION   :
			return "!@expression";
		case EXPR_BIT_NEGATION :
			return "~@expression";
		case EXPR_SIZEOF       :
			return "sizeof @expression";
		case EXPR_CAST         :
			return "(@declaration)@expression";
		case EXPR_MUL          :
			return "@expression*@expression";
		case EXPR_DIV          :
			return "@expression/@expression";
		case EXPR_MOD          :
			return "@expression%@expression";
		case EXPR_ADD           :
			return "@expression+@expression";
		case EXPR_SUB           :
			return "@expression-@expression";
		case EXPR_LEFTSHIFT     :
			return "@expression<<@expression";
		case EXPR_RIGHTSHIFT    :
			return "@expression>>@expression";
		case EXPR_GREATER          :
			return "@expression>@expression";
		case EXPR_GREATEREQU       :
			return "@expression>=@expression";
		case EXPR_LESS          :
			return "@expression<@expression";
		case EXPR_LESSEQU       :
			return "@expression<=@expression";

		case EXPR_EQUAL         :
			return "@expression==@expression";
		case EXPR_UNEQUAL       :
			return "@expression!=@expression";
		case EXPR_BIT_AND       :
			return "@expression&@expression";
		case EXPR_BIT_EXOR     :
			return "@expression^@expression";
		case EXPR_BIT_INOR      :
			return "@expression|@expression";
		case EXPR_LOGIC_AND    :
			return "@expression&&@expression";
		case EXPR_LOGIC_OR      :
			return "@expression||@expression";
		case EXPR_CONDITION     :
			return "@expression?@expression";
		case EXPR_COLON		 :
			return "@expression:@expression";
		case EXPR_ASSIGN        :
			return "@expression=@expression";
		case EXPR_MUL_ASSIGN   :
			return "@expression*=@expression";
		case EXPR_DIV_ASSIGN    :
			return "@expression/=@expression";
		case EXPR_MOD_ASSIGN   :
			return "@expression%=@expression";
		case EXPR_ADD_ASSIGN   :
			return "@expression+=@expression";
		case EXPR_SUB_ASSIGN    :
			return "@expression-=@expression";
		case EXPR_LSHT_ASSIGN   :
			return "@expression<<=@expression";
		case EXPR_RSHT_ASSIGN   :
			return "@expression>>=@expression";
		case EXPR_BITAND_ASSIGN :
			return "@expression&=@expression";
		case EXPR_BITEXOR_ASSIGN :
			return "@expression^=@expression";
		case EXPR_BITINOR_ASSIGN :
			return "@expression|=@expression";

		case EXPR_COMMA    :
			return "@expression,@expression";
		case EXPR_ARG      :
			return "@expression,@expression";
		default:
			break;
	}
	return "@ERROR";
}
VOID CExpressionOpKindInit ( VOID ){
//	BOOL   (*isConstantNumber)( U4 operatorKind );
	CExpressionOpKind.isConstantNumber = isConstantNumber;
//	BOOL   (*isIdentifier)( U4 operatorKind );
	CExpressionOpKind.isIdentifier = isIdentifier;
//	BOOL   (*isConstString)( U4 operatorKind );
	CExpressionOpKind.isConstString = isConstString;
//	BOOL   (*isParentheseExp)( U4 operatorKind );
	CExpressionOpKind.isParentheseExp = isParentheseExp;
//	BOOL   (*isDeclaration)( U4 operatorKind );
	CExpressionOpKind.isDeclaration = isDeclaration;
//	BOOL   (*isStatement)( U4 operatorKind );
	CExpressionOpKind.isStatement = isStatement;
//	BOOL   (*isInitializer)( U4 operatorKind );
	CExpressionOpKind.isInitializer = isInitializer;
//	BOOL   (*isPostfixOp)( U4 operatorKind );
	CExpressionOpKind.isPostfixOp = isPostfixOp;
//	BOOL   (*isUnaryOp)( U4 operatorKind );
	CExpressionOpKind.isUnaryOp = isUnaryOp;
//	BOOL   (*isCastOp)( U4 operatorKind );
	CExpressionOpKind.isCastOp = isCastOp;
//	BOOL   (*isMultiplicativeOp)( U4 operatorKind );
	CExpressionOpKind.isMultiplicativeOp = isMultiplicativeOp;
//	BOOL   (*isAdditiveOp)( U4 operatorKind );
	CExpressionOpKind.isAdditiveOp = isAdditiveOp;
//	BOOL   (*isShiftOp)( U4 operatorKind );
	CExpressionOpKind.isShiftOp = isShiftOp;
//	BOOL   (* isRelationalOp)( U4 operatorKind );
	CExpressionOpKind.isRelationalOp = isRelationalOp;
//	BOOL   (*isEqualityOp)( U4 operatorKind );
	CExpressionOpKind.isEqualityOp = isEqualityOp;
	//	BOOL   (*isBitwiseAndOp)( U4 operatorKind );
	CExpressionOpKind.isBitwiseAndOp = isBitwiseAndOp;
//	BOOL   (*isBitwiseExclusiveOrOp)( U4 operatorKind );
	CExpressionOpKind.isBitwiseExclusiveOrOp = isBitwiseExclusiveOrOp;
//	BOOL   (*isBitwiseInclusiveOrOp)( U4 operatorKind );
	CExpressionOpKind.isBitwiseInclusiveOrOp = isBitwiseInclusiveOrOp;
//	BOOL   (*isLogicalAndOp)( U4 operatorKind );
	CExpressionOpKind.isLogicalAndOp = isLogicalAndOp;
//	BOOL  (*isLogicalOrOp)( U4 operatorKind );
	CExpressionOpKind.isLogicalOrOp = isLogicalOrOp;
//	BOOL   (*isConditionalOp)( U4 operatorKind );
	CExpressionOpKind.isConditionalOp = isConditionalOp;
	//	BOOL   (*isAssignmentOp)( U4 operatorKind );
	CExpressionOpKind.isAssignmentOp = isAssignmentOp;
//	BOOL   (*isCommaOp)( U4 operatorKind );
	CExpressionOpKind.isCommaOp = isCommaOp;
//	BOOL   (*isArgumentDelimiter)( U4 operatorKind );
	CExpressionOpKind.isArgumentDelimiter = isArgumentDelimiter;
//	PSZ  (*CcGetOpLabel)( U4 operatorKind );
	CExpressionOpKind.CcGetOpLabel = CcGetOpLabel;
}

TYPE_POSTFIXOP DLL_EXPORT CPostfixOpKind;
EXTERNAL_SYMBOL(CPostfixOpKind );

//	BOOL   (*isArrayCall)( U4 operatorKind );
static BOOL   isArrayCall( U4 operatorKind ){
	return EXPR_ARRAY == operatorKind;
}
//	BOOL   (*isFunctionCall)( U4 operatorKind );
static BOOL   isFunctionCall( U4 operatorKind ){
	return EXPR_FUNCTIONCALL == operatorKind;
}
//	BOOL   (*isDot)( U4 operatorKind );
static BOOL   isDot( U4 operatorKind ){
	return EXPR_MEMBER == operatorKind;
}
//	BOOL   (*isArrow)( U4 operatorKind );
static BOOL   isArrow( U4 operatorKind ){
	return EXPR_PTRMEMBER == operatorKind;
}
//	BOOL   (*isPostIncrement)( U4 operatorKind );
static BOOL   isPostIncrement( U4 operatorKind ){
	return EXPR_POSTINC == operatorKind;
}
//	BOOL   (*isPostDecrement)( U4 operatorKind );
static BOOL   isPostDecrement( U4 operatorKind ){
	return EXPR_POSTDEC == operatorKind;
}
//	BOOL   (*isCompoundLiterals)( U4 operatorKind );
static BOOL   isCompoundLiterals( U4 operatorKind ){
	return EXPR_COMPOUNDLITERALS == operatorKind;
}
VOID CPostfixOpKindInit( VOID ){
	CPostfixOpKind.isArrayCall = isArrayCall;
//	BOOL   (*isFunctionCall)( U4 operatorKind );
	CPostfixOpKind.isFunctionCall = isFunctionCall;
//	BOOL   (*isDot)( U4 operatorKind );
	CPostfixOpKind.isDot = isDot;
//	BOOL   (*isArrow)( U4 operatorKind );
	CPostfixOpKind.isArrow = isArrow;
//	BOOL   (*isPostIncrement)( U4 operatorKind );
	CPostfixOpKind.isPostIncrement = isPostIncrement;
//	BOOL   (*isPostDecrement)( U4 operatorKind );
	CPostfixOpKind.isPostDecrement = isPostDecrement;
//	BOOL   (*isCompoundLiterals)( U4 operatorKind );
	CPostfixOpKind.isCompoundLiterals = isCompoundLiterals;
}

TYPE_UNARYOP DLL_EXPORT CUnaryOpKind;
EXTERNAL_SYMBOL(CUnaryOpKind );
//	BOOL   (*isPreIncrement)( U4 operatorKind );
static BOOL   isPreIncrement( U4 operatorKind ){
	return EXPR_PREINC == operatorKind;
}
//	BOOL   (* isPreDecrement)( U4 operatorKind );
static BOOL   isPreDecrement( U4 operatorKind ){
	return EXPR_PREDEC == operatorKind;
}
//	BOOL   (*isGetAddressOp)( U4 operatorKind );
static BOOL   isGetAddressOp( U4 operatorKind ){
	return EXPR_ADDRESS == operatorKind;
}
//	BOOL  (* isIndirectionOp)( U4 operatorKind );
static BOOL   isIndirectionOp( U4 operatorKind ){
	return EXPR_ASTERISK == operatorKind;
}
//	BOOL   (*isUnaryPlus)( U4 operatorKind );
static BOOL   isUnaryPlus( U4 operatorKind ){
	return EXPR_PLUS == operatorKind;
}
//	BOOL  (* isUnaryMinus)( U4 operatorKind );
static BOOL   isUnaryMinus( U4 operatorKind ){
	return EXPR_MINUS == operatorKind;
}
//	BOOL  (* isBitwiseNegation)( U4 operatorKind );
static BOOL   isBitwiseNegation( U4 operatorKind ){
	return EXPR_BIT_NEGATION == operatorKind;
}
//	BOOL  (* isValueNegation)( U4 operatorKind );
static BOOL   isValueNegation( U4 operatorKind ){
	return EXPR_NEGATION == operatorKind;
}
//	BOOL  (* isSizeof)( U4 operatorKind );
static BOOL   isSizeof( U4 operatorKind ){
	return EXPR_SIZEOF == operatorKind;
}
VOID CUnaryOpKindInit( VOID ){
//	BOOL   (*isPreIncrement)( U4 operatorKind );
	CUnaryOpKind.isPreIncrement = isPreIncrement;
//	BOOL   (* isPreDecrement)( U4 operatorKind );
	CUnaryOpKind.isPreDecrement = isPreDecrement;
//	BOOL   (*isGetAddressOp)( U4 operatorKind );
	CUnaryOpKind.isGetAddressOp = isGetAddressOp;
//	BOOL  (* isIndirectionOp)( U4 operatorKind );
	CUnaryOpKind.isIndirectionOp = isIndirectionOp;
//	BOOL   (*isUnaryPlus)( U4 operatorKind );
	CUnaryOpKind.isUnaryPlus = isUnaryPlus;
//	BOOL  (* isUnaryMinus)( U4 operatorKind );
	CUnaryOpKind.isUnaryMinus = isUnaryMinus;
//	BOOL  (* isBitwiseNegation)( U4 operatorKind );
	CUnaryOpKind.isBitwiseNegation = isBitwiseNegation;
//	BOOL  (* isValueNegation)( U4 operatorKind );
	CUnaryOpKind.isValueNegation = isValueNegation;
//	BOOL  (* isSizeof)( U4 operatorKind );
	CUnaryOpKind.isSizeof = isSizeof;
}


TYPE_MULTIPLICATIVEOP DLL_EXPORT CMultiOpKind;
EXTERNAL_SYMBOL(CMultiOpKind );
//	BOOL   (*isMultiplicative)( U4 operatorKind );
static BOOL   isMultiplicative( U4 operatorKind ){
	return EXPR_MUL == operatorKind;
}
//	BOOL   (*isDivision)( U4 operatorKind );.
static BOOL   isDivision( U4 operatorKind ){
	return EXPR_DIV == operatorKind;
}
//	BOOL   (*isRemainderOp)( U4 operatorKind );
static BOOL   isRemainderOp( U4 operatorKind ){
	return EXPR_MOD == operatorKind;
}
VOID CMultiOpKindInit(VOID){
//	BOOL   (*isMultiplicative)( U4 operatorKind );
	CMultiOpKind.isMultiplicative = isMultiplicative;
//	BOOL   (*isDivision)( U4 operatorKind );
	CMultiOpKind.isDivision = isDivision;
//	BOOL   (*isRemainderOp)( U4 operatorKind );
	CMultiOpKind.isRemainderOp = isRemainderOp;
}

TYPE_ADDITIVEOP DLL_EXPORT CAdditiveOpKind;
EXTERNAL_SYMBOL(CAdditiveOpKind );
//	BOOL   (*isAdditive)( U4 operatorKind );
static BOOL   isAdditive( U4 operatorKind ){
	return EXPR_ADD == operatorKind;
}
//	BOOL   (*isSubtraction)( U4 operatorKind );.
static BOOL   isSubtraction( U4 operatorKind ){
	return EXPR_SUB == operatorKind;
}
VOID CAdditiveOpKindInit( VOID ){
//	BOOL   (*isAdditive)( U4 operatorKind );
	CAdditiveOpKind.isAdditive = isAdditive;
//	BOOL   (*isSubtraction)( U4 operatorKind );
	CAdditiveOpKind.isSubtraction = isSubtraction;
}
TYPE_SHIFTOP DLL_EXPORT CShiftOpKind;
EXTERNAL_SYMBOL(CShiftOpKind );
/*debug,12/10/24,S*/
static BOOL   isLeftShift( U4 operatorKind ){
	return EXPR_LEFTSHIFT == operatorKind;
}
static BOOL   isRightShift( U4 operatorKind ){
	return EXPR_RIGHTSHIFT == operatorKind;
}
/*debug,12/10/24,E*/
VOID CShiftOpKindInit( VOID ){
//	BOOL   (*isLeftShift)( U4 operatorKind );
	CShiftOpKind.isLeftShift = isLeftShift;
//	BOOL   (*isRightShift)( U4 operatorKind );
	CShiftOpKind.isRightShift = isRightShift;
}
TYPE_RELATIONALOP DLL_EXPORT CRelationalOpKind;
EXTERNAL_SYMBOL(CRelationalOpKind );
static BOOL   isGreaterOrEqual( U4 operatorKind ){
	return EXPR_GREATEREQU == operatorKind;
}
static BOOL   isGreater( U4 operatorKind ){
	return EXPR_GREATER == operatorKind;
}
static BOOL   isLessOrEqual( U4 operatorKind ){
	return EXPR_LESSEQU == operatorKind;
}
static BOOL   isLess( U4 operatorKind ){
	return EXPR_LESS == operatorKind;
}

VOID CRelationalOpKindInit( VOID ){
//	BOOL   (*isGreaterOrEqual)( U4 operatorKind );
	CRelationalOpKind.isGreaterOrEqual = isGreaterOrEqual;
//	BOOL   (*isGreater)( U4 operatorKind );
	CRelationalOpKind.isGreater = isGreater;
//	BOOL   (*isLessOrEqual)( U4 operatorKind );
	CRelationalOpKind.isLessOrEqual = isLessOrEqual;
//	BOOL   (*isLess)( U4 operatorKind );
	CRelationalOpKind.isLess = isLess;
}
TYPE_EQUALITYOP DLL_EXPORT CEqualityOpKind;
EXTERNAL_SYMBOL(CEqualityOpKind );
static BOOL   isEqualOp( U4 operatorKind ){
	return EXPR_EQUAL == operatorKind;
}
static BOOL   isUnequalOp( U4 operatorKind ){
	return EXPR_UNEQUAL == operatorKind;
}
VOID CEqualityOpKindInit( VOID ){
	CEqualityOpKind.isEqualOp = isEqualOp;
	CEqualityOpKind.isUnequalOp = isUnequalOp;
}

TYPE_CONDITIONOP DLL_EXPORT CConditionOpKind;
EXTERNAL_SYMBOL(CConditionOpKind );
static BOOL   isQuestionOp( U4 operatorKind ){
	return EXPR_CONDITION == operatorKind;
}
static BOOL   isColonOp( U4 operatorKind ){
	return EXPR_COLON == operatorKind;
}
VOID CConditionOpKindInit( VOID ){
	CConditionOpKind.isQuestionOp = isQuestionOp;
	CConditionOpKind.isColonOp = isColonOp;
}

TYPE_ASSIGNMENTOP DLL_EXPORT CAssignOpKind;
EXTERNAL_SYMBOL(CAssignOpKind );
static BOOL   isAssignment( U4 operatorKind ){
	return EXPR_ASSIGN == operatorKind;
}
static BOOL   isMultiAssignOp( U4 operatorKind ){
	return EXPR_MUL_ASSIGN == operatorKind;
}
static BOOL   isDivisionAssignOp( U4 operatorKind ){
	return EXPR_DIV_ASSIGN == operatorKind;
}
static BOOL   isRemainderAssignOp( U4 operatorKind ){
	return EXPR_MOD_ASSIGN == operatorKind;
}
static BOOL   isAddAssignOp( U4 operatorKind ){
	return EXPR_ADD_ASSIGN == operatorKind;
}
static BOOL   isSubtractionAssignOp( U4 operatorKind ){
	return EXPR_SUB_ASSIGN == operatorKind;
}
static BOOL   isLeftShiftAssignOp( U4 operatorKind ){
	return EXPR_LSHT_ASSIGN == operatorKind;
}
static BOOL   isRightShiftAssignOp( U4 operatorKind ){
	return EXPR_RSHT_ASSIGN == operatorKind;
}
static BOOL   isBitAndAssignOp( U4 operatorKind ){
	return EXPR_BITAND_ASSIGN == operatorKind;
}
static BOOL   isBitExOrAssignOp( U4 operatorKind ){
	return EXPR_BITEXOR_ASSIGN == operatorKind;
}
static BOOL   isBitOrAssignOp( U4 operatorKind ){
	return EXPR_BITINOR_ASSIGN == operatorKind;
}
VOID CAssignOpKindInit ( VOID ){
//	BOOL   (*isAssignment)( U4 operatorKind );
	CAssignOpKind.isAssignment = isAssignment;
//	BOOL   (*isMultiAssignOp)( U4 operatorKind );
	CAssignOpKind.isMultiAssignOp = isMultiAssignOp;
//	BOOL   (*isDivisionAssignOp)( U4 operatorKind );
	CAssignOpKind.isDivisionAssignOp = isDivisionAssignOp;
//	BOOL   (*isRemainderAssignOp)( U4 operatorKind );
	CAssignOpKind.isRemainderAssignOp = isRemainderAssignOp;
//	BOOL   (*isAddAssignOp)( U4 operatorKind );
	CAssignOpKind.isAddAssignOp = isAddAssignOp;
//	BOOL   (*isSubtractionAssignOp)( U4 operatorKind );
	CAssignOpKind.isSubtractionAssignOp = isSubtractionAssignOp;
//	BOOL   (*isLeftShiftAssignOp)( U4 operatorKind );
	CAssignOpKind.isLeftShiftAssignOp = isLeftShiftAssignOp;
//	BOOL   (*isRightShiftAssignOp)( U4 operatorKind );
	CAssignOpKind.isRightShiftAssignOp = isRightShiftAssignOp;
//	BOOL   (*isBitAndAssignOp)( U4 operatorKind );
	CAssignOpKind.isBitAndAssignOp = isBitAndAssignOp;
//	BOOL   (*isBitExOrAssignOp)( U4 operatorKind );
	CAssignOpKind.isBitExOrAssignOp = isBitExOrAssignOp;
//	BOOL   (*isBitOrAssignOp)( U4 operatorKind );
	CAssignOpKind.isBitOrAssignOp = isBitOrAssignOp;

}
TYPE_TYPEINFO DLL_EXPORT CTypeInfo;
EXTERNAL_SYMBOL(CTypeInfo );
//	BOOL (*isBasicType)( AST astIndex );
static BOOL isTBasicType( AST astIndex ){
	return CcTypeIsBasicType( astIndex );
}
//	BOOL (*isArray)( AST astIndex );
static BOOL isTArray( AST astIndex ){
	return CcTypeIsArray( astIndex );
}
//	BOOL (*isPointer)( AST astIndex );
static BOOL isTPointer( AST astIndex ){
	return CcTypeIsPointer( astIndex );
}
//	BOOL (*isFunction)( AST astIndex );
static BOOL isTFunction( AST astIndex ){
	return CcTypeIsFunction( astIndex );
}
//	BOOL (*isStruct)( AST astIndex );
static BOOL isTStruct( AST astIndex ){
	return CcTypeIsStruct( astIndex );
}
//	BOOL (*isUnion)( AST astIndex );
static BOOL isTUnion( AST astIndex ){
	return CcTypeIsUnion( astIndex );
}
//	BOOL (*isEnum)( AST astIndex );
static BOOL isTEnum( AST astIndex ){
	return CcTypeIsEnum( astIndex );
}
//	BOOL (*isBitfield)( AST astIndex );
static BOOL isTBitfield( AST astIndex ){
	return CcTypeIsBitfield( astIndex );
}
//	BOOL (*isSigned)( AST astIndex );
static BOOL isTSigned( AST astIndex ){
	return CcTypeIsSigned(astIndex);
}
//	BOOL (*isUnSigned)( AST astIndex );
static BOOL isTUnSigned( AST astIndex ){
	return CcTypeIsUnSigned(astIndex);
}
//	BOOL (*isLongLong)( AST astIndex );
static BOOL isTLongLong( AST astIndex ){
	return CcTypeIsLongLong(astIndex);
}
//	BOOL (*isLong)( AST astIndex );
static BOOL isTLong( AST astIndex ){
	return CcTypeIsLong(astIndex);
}
//	BOOL (*isShort)( AST astIndex );
static BOOL isTShort( AST astIndex ){
	return CcTypeIsShort(astIndex);
}
//	BOOL (*isInteger)( AST astIndex );
static BOOL isTInteger( AST astIndex ){
	return CcTypeIsInteger(astIndex);
}
//	BOOL (*isFloating)( AST astIndex );
static BOOL isTFloating( AST astIndex ){
	return CcTypeIsFloating(astIndex);
}
//	BOOL (*isConst)( AST astIndex );
static BOOL isTConst( AST astIndex ){
	return CcTypeIsConst(astIndex);
}
//	BOOL (*isVolatile)( AST astIndex );
static BOOL isTVolatile( AST astIndex ){
	return CcTypeIsVolatile(astIndex);
}
//	BOOL (*isRestrict)( AST astIndex );
static BOOL isTRestrict( AST astIndex ){
	return CcTypeIsRestrict(astIndex);
}
static PSZ getBasicTypeName( AST astIndex ){
	switch( astIndex )
	{
	case TYPE_VOID:
		return (  "void" );
		break;
	case TYPE_CHAR:
		return(  "char" );
		break;
	case TYPE_SIGNED_CHAR:
		return(  "signed char");
		break;
	case TYPE_UNSIGNED_CHAR:
		return(  "unsigned char");
		break;
	case TYPE_SHORT:
		return( "short");
		break;
	case TYPE_SIGNED_SHORT:
		return(  "signed short");
		break;
	case TYPE_UNSIGNED_SHORT:
		return( "unsigned short");
		break;
	case TYPE_LONG:
		return(  "long");
		break;
	case TYPE_SIGNED_LONG:
		return( "signed long");
		break;
	case TYPE_UNSIGNED_LONG:
		return( "unsigned long");
		break;
	case TYPE_LONG_LONG:
		return(  "long long");
		break;
	case TYPE_SIGNED_LONG_LONG:
		return( "signed long long");
		break;
	case TYPE_UNSIGNED_LONG_LONG:
		return(  "unsigned long long");
		break;
	case TYPE_INT:
		return( "int");
		break;
	case TYPE_SIGNED_INT:
		return( "signed int");
		break;
	case TYPE_UNSIGNED_INT:
		return( "unsigned int");
		break;
	case TYPE_FLOAT:
		return(  "float");
		break;
	case TYPE_DOUBLE:
		return(  "double");
		break;
	case TYPE_LONG_DOUBLE:
		return( "long double");
		break;
	default:
		break;
	}
	return NULL;
}
VOID CTypeInfoInit ( VOID ){
//	AST  (*getMax)( VOID );
	CTypeInfo.getMax = stTypeInfoAccess.getMax;
//	BOOL (*isBasicType)( AST astIndex );
	CTypeInfo.isBasicType = isTBasicType;
//	BOOL (*isArray)( AST astIndex );
	CTypeInfo.isArray = isTArray;
//	BOOL (*isPointer)( AST astIndex );
	CTypeInfo.isPointer = isTPointer;
//	BOOL (*isFunction)( AST astIndex );
	CTypeInfo.isFunction = isTFunction;
//	BOOL (*isStruct)( AST astIndex );
	CTypeInfo.isStruct = isTStruct;
//	BOOL (*isUnion)( AST astIndex );
	CTypeInfo.isUnion = isTUnion;
//	BOOL (*isEnum)( AST astIndex );
	CTypeInfo.isEnum = isTEnum;
//	BOOL (*isBitfield)( AST astIndex );
	CTypeInfo.isBitfield = isTBitfield;
//	BOOL (*isSigned)( AST astIndex );
	CTypeInfo.isSigned = isTSigned;
//	BOOL (*isUnSigned)( AST astIndex );
	CTypeInfo.isUnSigned = isTUnSigned;
//	BOOL (*isLongLong)( AST astIndex );
	CTypeInfo.isLongLong = isTLongLong;
//	BOOL (*isLong)( AST astIndex );
	CTypeInfo.isLong = isTLong;
//	BOOL (*isShort)( AST astIndex );
	CTypeInfo.isShort = isTShort;
//	BOOL (*isInteger)( AST astIndex );
	CTypeInfo.isInteger = isTInteger;
//	BOOL (*isFloating)( AST astIndex );
	CTypeInfo.isFloating = isTFloating;
//	BOOL (*isConst)( AST astIndex );
	CTypeInfo.isConst = isTConst;
//	BOOL (*isVolatile)( AST astIndex );
	CTypeInfo.isVolatile = isTVolatile;
//	BOOL (*isRestrict)( AST astIndex );
	CTypeInfo.isRestrict = isTRestrict;
//	U4   (*getTypeSize)( AST astIndex );
	CTypeInfo.getTypeSize = stTypeInfoAccess.size.get;
//	AST   (*getElementType )( AST astIndex );
	CTypeInfo.getElementType = stTypeInfoAccess.elementType.get;
//	AST   (*getNoneQualifierType )( AST astIndex );
	CTypeInfo.getNoneQualifierType = CcTypeGetNoQualType;
//	AST   (*getMemberChain )( AST astIndex );
	CTypeInfo.getMemberChain = stTypeInfoAccess.memChain.get;
//	AST   (*getTagInfo )( AST astIndex );
	CTypeInfo.getTagInfo = stTypeInfoAccess.tagInfo.get;
	CTypeInfo.getBasicTypeName = getBasicTypeName;
}
TYPE_SYMBOLINFO DLL_EXPORT CSymbol;
EXTERNAL_SYMBOL(CSymbol );
//	BOOL (*isExtern) ( AST astIndex );
static BOOL isSExtern( AST astIndex ){
	return CLASS_EXTERN == stSymbolInfoAccess.symClass.get( astIndex );
}
//	BOOL (*isStatic) ( AST astIndex );
static BOOL isSStatic( AST astIndex ){
	return CLASS_STATIC == stSymbolInfoAccess.symClass.get( astIndex );
}
//	BOOL (*isRegister) ( AST astIndex );
static BOOL isSRegister( AST astIndex ){
	return CLASS_REGISTER == stSymbolInfoAccess.symClass.get( astIndex );
}
//	BOOL (*isAuto) ( AST astIndex );
static BOOL isSAuto( AST astIndex ){
	return CLASS_AUTO == stSymbolInfoAccess.symClass.get( astIndex );
}
//	BOOL (*isTypedefId)( AST astIndex );
static BOOL isSTypedefId( AST astIndex ){
	return SYMBOL_KIND_TYPEDEFID == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isEnumConstant)( AST astIndex );
static BOOL isSEnumConstant( AST astIndex ){
	return SYMBOL_KIND_ENUMCONST == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isFunction)( AST astIndex );
static BOOL isSFunction( AST astIndex ){
	return SYMBOL_KIND_FUNCTION == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isVariable)( AST astIndex );
static BOOL isSVariable( AST astIndex ){
	return SYMBOL_KIND_VARIABLE == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isMember)( AST astIndex );
static BOOL isSMember( AST astIndex ){
	return SYMBOL_KIND_MEMBER == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isParameter)( AST astIndex );
static BOOL isSParameter( AST astIndex ){
	return SYMBOL_KIND_PARAM == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isTag)( AST astIndex );
static BOOL isSTag( AST astIndex ){
	return SYMBOL_KIND_TAG == stSymbolInfoAccess.kind.get( astIndex );
}
//	BOOL (*isLabel)( AST astIndex );
static BOOL isSLabel( AST astIndex ){
	return SYMBOL_KIND_LABEL == stSymbolInfoAccess.kind.get( astIndex );
}
VOID CSymbolInit( VOID ){
//	AST  (*getMax)( VOID );
	CSymbol.getMax = stSymbolInfoAccess.getMax;
//	BOOL (*isExtern) ( AST astIndex );
	CSymbol.isExtern = isSExtern;
//	BOOL (*isStatic) ( AST astIndex );
	CSymbol.isStatic = isSStatic;
//	BOOL (*isRegister) ( AST astIndex );
	CSymbol.isRegister = isSRegister;
//	BOOL (*isAuto) ( AST astIndex );
	CSymbol.isAuto = isSAuto;
//	BOOL (*isTypedefId)( AST astIndex );
	CSymbol.isTypedefId = isSTypedefId;
//	BOOL (*isEnumConstant)( AST astIndex );
	CSymbol.isEnumConstant = isSEnumConstant;
//	BOOL (*isFunction)( AST astIndex );
	CSymbol.isFunction = isSFunction;
//	BOOL (*isVariable)( AST astIndex );
	CSymbol.isVariable = isSVariable;
//	BOOL (*isMember)( AST astIndex );
	CSymbol.isMember = isSMember;
//	BOOL (*isParameter)( AST astIndex );
	CSymbol.isParameter = isSParameter;
//	BOOL (*isTag)( AST astIndex );
	CSymbol.isTag = isSTag;
//	BOOL (*isLabel)( AST astIndex );
	CSymbol.isLabel = isSLabel;
//	AST  (*getType)( AST astIndex );
	CSymbol.getType = stSymbolInfoAccess.type.get;
//	PSZ  (*getName)( AST astIndex );
	CSymbol.getName = stSymbolInfoAccess.name.get;
//	AST  (*getCodeScope)( AST astIndex );
	CSymbol.getCodeScope = stSymbolInfoAccess.codeScp.get;
//	BOOL  (*bReferred)( AST astIndex );
	CSymbol.bReferred = stSymbolInfoAccess.referred.get;
//	AST (*getFunctionBody) ( AST astIndex );
	CSymbol.getFunctionBody = stSymbolInfoAccess.functionBody.get;
//	AST (*getLinkage) ( AST astIndex );
	CSymbol.getLinkage = stSymbolInfoAccess.linkage.get;
//	AST (*getDataSection) ( AST astIndex );
	CSymbol.getDataSection = stSymbolInfoAccess.dataSection.get;
//	AST (*getInitExp) ( AST astIndex );
	CSymbol.getInitExp = stSymbolInfoAccess.initialExpList.get;
//	AST (*getInitValue) ( AST astIndex );
	CSymbol.getInitValue = stSymbolInfoAccess.value.get;
	//	AST (*getMemberOffsetBytes) ( AST astIndex );
	CSymbol.getMemberOffsetBytes = stSymbolInfoAccess.memOffset.get;
}
TYPE_VALUEINFO DLL_EXPORT CValueInfo;
EXTERNAL_SYMBOL(CValueInfo );
static BOOL  isVFloating(AST astIndex ){
	AST astType =stValueInfoAccess.type.get(astIndex);
	return CcTypeIsFloating( astType );
}
static INTVALUE getIntCValue( AST  astIndex ){
	INTVALUE intvar;
	VARVALUE var = CcValueGetInteger( astIndex );
	intvar.sign = 1;
	if( var.sign < 0 ){
		intvar.sign = -1;
	}
	intvar.u8Remainder = var.u8Remainder;
	return intvar;
}
VOID CValueInfoInit( VOID ){
//	AST  (*getMax)( VOID );
	CValueInfo.getMax = stValueInfoAccess.getMax;
//	AST  (*getType)( AST astIndex );
	CValueInfo.getType = stValueInfoAccess.type.get;
//	BOOL  (*isFloating)(AST astIndex );
	CValueInfo.isFloating = isVFloating;
//	VARVALUE (*getIntegerValue)( AST astIndex );
	CValueInfo.getIntegerValue = getIntCValue;
//	DOUBLE (*getFloatingValue)( AST astIndex );
	CValueInfo.getFloatingValue = CcValueGetFloating;
}

TYPE_INITIALIZER DLL_EXPORT CInitializer;
EXTERNAL_SYMBOL(CInitializer );
static BOOL isIAddressConstantExp( AST astIndex ){
	return stExpressionListAccess.constFlg.get( astIndex ) == INIT_CONSTANT;
}
static BOOL isIConstantExp( AST astIndex ){
	return  ( stExpressionListAccess.constFlg.get( astIndex ) == CONSTANT_VALUE );
}
static BOOL isBlockInitializer( AST astIndex ){
	return stExpressionListAccess.parameterKind.get( astIndex ) == KIND_INITIALEXPLIST;
}
static BOOL isExpInitializer( AST astIndex ){
	return  stExpressionListAccess.parameterKind.get( astIndex ) == KIND_EXPRESSIONINFO;
}
static BOOL isParentDeclarator( AST astIndex ){
	return  stExpressionListAccess.parentKind.get( astIndex ) == KIND_DECLARATOR;
}
static BOOL isParentExpression( AST astIndex ){
	return  stExpressionListAccess.parentKind.get( astIndex ) == KIND_EXPRESSIONINFO;
}
static BOOL isParentInitializer( AST astIndex ){
	return  stExpressionListAccess.parentKind.get( astIndex ) == KIND_INITIALEXPLIST;
}
VOID CInitializerInit( VOID ){
	CInitializer.getChildInitializer = stExpressionListAccess.expressionList.get;
	CInitializer.getCodeScope = stExpressionListAccess.codeScp.get;
	CInitializer.getDesignation = stExpressionListAccess.designation.get;
	CInitializer.getExpression = stExpressionListAccess.expression.get;
	CInitializer.getMax = stExpressionListAccess.getMax;
	CInitializer.getNextOne = stExpressionListAccess.next.get;
	CInitializer.isAddressConstant = isIAddressConstantExp;
	CInitializer.isConstatnt = isIConstantExp;
	CInitializer.isBlockInitializer = isBlockInitializer;
	CInitializer.isExpInitializer = isExpInitializer;
	CInitializer.isParentDeclarator = isParentDeclarator;
	CInitializer.isParentExpression = isParentExpression;
	CInitializer.isParentInitializer = isParentInitializer;
	CInitializer.parent_getDeclarator = stExpressionListAccess.parent.get;
	CInitializer.parent_getExpression = stExpressionListAccess.parent.get;
	CInitializer.parent_getInitializer = stExpressionListAccess.parent.get;
}
TYPE_INITDESIGNATION DLL_EXPORT CDesignation;
EXTERNAL_SYMBOL(CDesignation );
static BOOL isDesiArray( AST astIndex ){
	return  stInitDesignationAccess.kind.get( astIndex ) == DESIGNATION_ARRAY;
}
static BOOL isDesiMember( AST astIndex ){
	return  stInitDesignationAccess.kind.get( astIndex ) == DESIGNATION_MEMBER;
}
VOID CDesignationInit( VOID ){
	CDesignation.getArrayIndex = stInitDesignationAccess.const_expression.get;
	CDesignation.getChild = stInitDesignationAccess.child.get;
	CDesignation.getCodeScope = stInitDesignationAccess.codeScp.get;
	CDesignation.getInitializer = stInitDesignationAccess.initializer.get;
	CDesignation.getMax = stInitDesignationAccess.getMax;
	CDesignation.getMemberSymbol = stInitDesignationAccess.identifier.get;
	CDesignation.getParent = stInitDesignationAccess.parent.get;
	CDesignation.isArray = isDesiArray;
	CDesignation.isMember = isDesiMember;
}

TYPE_UNITECHAIN DLL_EXPORT CUniteChain;
EXTERNAL_SYMBOL(CUniteChain );
//	BOOL (*isSymbolInfo)( AST astIndex );
static BOOL isUSymbolInfo ( AST astIndex ){
	return KIND_SYMDEFINFO == stUniteChainAccess.kind.get( astIndex );
}
//	BOOL (*isStatement)( AST astIndex );
static BOOL isUStatement ( AST astIndex ){
	return KIND_STATEMENTINFO == stUniteChainAccess.kind.get( astIndex );
}
//	BOOL (*isDeclarations)( AST astIndex );
static BOOL isUDeclarations ( AST astIndex ){
	return KIND_DECLARATION == stUniteChainAccess.kind.get( astIndex );
}
VOID CUniteChainInit( VOID ){
//	AST  (*getMax)( VOID );
	CUniteChain.getMax = stUniteChainAccess.getMax;
//	BOOL (*isSymbolInfo)( AST astIndex );
	CUniteChain.isSymbolInfo = isUSymbolInfo;
//	BOOL (*isStatement)( AST astIndex );
	CUniteChain.isStatement = isUStatement;
//	BOOL (*isDeclarations)( AST astIndex );
	CUniteChain.isDeclarations = isUDeclarations;
//	AST  (*getSymbol)(AST astIndex);
	CUniteChain.getSymbol = stUniteChainAccess.parameter_sym.get;
//	AST  (*getStatement)(AST astIndex);
	CUniteChain.getStatement = stUniteChainAccess.parameter_stmt.get;
//	AST  (*getDeclaration)(AST astIndex);
	CUniteChain.getDeclaration = stUniteChainAccess.parameter_decl.get;
//	AST  (*getPreOne)(AST astIndex);
	CUniteChain.getPreOne = stUniteChainAccess.before.get;
//	AST  (*getNextOne)(AST astIndex);
	CUniteChain.getNextOne = stUniteChainAccess.next.get;
}
TYPE_CCLINKAGE DLL_EXPORT CLinkage;
EXTERNAL_SYMBOL(CLinkage );
VOID CLinkageInit( VOID ){
//	AST  (*getMax)( VOID );
	CLinkage.getMax = stCCLinkageAccess.getMax;
//	BOOL (*isExternal) ( AST astIndex );
	CLinkage.isExternal = stCCLinkageAccess.bExternal.get;
//	BOOL (*isReferred) ( AST astIndex );
	CLinkage.isReferred = stCCLinkageAccess.bReferred.get;
//	AST  (*getAllDeclarators)( AST astIndex );
	CLinkage.getAllSymbols = stCCLinkageAccess.allChain.get;
//	AST  (*getTenDeclarators)( AST astIndex );
	CLinkage.getTenSymbols = stCCLinkageAccess.tenDeclChain.get;
//	AST  (*getDefinitions)( AST astIndex );
	CLinkage.getDefinitions = stCCLinkageAccess.definitionChain.get;
//	AST  (*getDefSymbol)( AST astIndex );
	CLinkage.getDefSymbol = stCCLinkageAccess.definitionSym.get;
}
TYPE_TRANSLATIONUNIT DLL_EXPORT CTranslationUnit;
EXTERNAL_SYMBOL(CTranslationUnit );
VOID CTranslationUnitInit( VOID ){
//	AST  (*getMax)( VOID );
	CTranslationUnit.getMax = stCoreTranslationUnitAccess.getMax;
//	AST  (*getDeclaration)( AST astIndex );
	CTranslationUnit.getDeclaration = stCoreTranslationUnitAccess.declarationchain.get;
	/*debug,12/12/18,S*/
	CTranslationUnit.getFileIndex = stCoreTranslationUnitAccess.fileindex.get;
	CTranslationUnit.getVari = stCoreTranslationUnitAccess.preVariMax.get;
	CTranslationUnit.getFunc = stCoreTranslationUnitAccess.preFuncMax.get;
	CTranslationUnit.getLinkage = stCoreTranslationUnitAccess.preLinkageMax.get;
	/*debug,12/12/18,E*/
}
TYPE_STRINGS DLL_EXPORT CStrings;
EXTERNAL_SYMBOL(CStrings );
VOID CStringsInit( VOID ){
//	PSZ (*getString)( AST );
	CStrings.getString = stCcConstStringAccess.getStr;
//	S4 (*getLength)( AST );
	CStrings.getLength = stCcConstStringAccess.getLength;
}
const CC_OUTPUT_FUNCTIONS  DLL_EXPORT CCOutput = {
	&CDeclaration,
	&CTypeSpecifier,
	&CDeclarator,
	&CStatement,
	&CExpression,
	&CExpressionOpKind,
	&CPostfixOpKind,
	&CUnaryOpKind,
	&CMultiOpKind,
	&CAdditiveOpKind,
	&CShiftOpKind,
	&CRelationalOpKind,
	&CEqualityOpKind,
	&CConditionOpKind,
	&CAssignOpKind,
	&CTypeInfo,
	&CSymbol,
	&CValueInfo,
	&CUniteChain,
	&CLinkage,
	&CTranslationUnit,
	&CStrings
};
EXTERNAL_SYMBOL( CCOutput );
